package com.etime.shycourse.services.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.etime.shycourse.config.Tools;
import com.etime.shycourse.dao.CoursecommentMapper;
import com.etime.shycourse.dto.CoursecommentDto;
import com.etime.shycourse.dto.CurrentUser;
import com.etime.shycourse.filterMsg.FilterMsgData;
import com.etime.shycourse.filterMsg.FilterMsgTool;
import com.etime.shycourse.filterMsg.ReturnMsgData;
import com.etime.shycourse.pojo.Coursecomment;
import com.etime.shycourse.services.interfaces.WxCoursecommentServices;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Date;
import java.util.List;

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author wb
 * @since 2022-03-02
 */
@Service
public class WxCoursecommentServiceImpl implements WxCoursecommentServices {
    @Autowired
    private Tools tools;
    @Autowired
    private CoursecommentMapper mapper;
    @Autowired
    private FilterMsgTool filterMsgTool;

    /**
     * 验证用户输入内容是否有敏感内容。
     *
     * @param openid  用户的openid
     * @param content 需要验证的内容
     * @return -1 验证超时
     * 1 通过
     * -3 有敏感词汇
     */
    private int checkcontent(String openid, String content) {
        int rtn = -1;
        FilterMsgData data = new FilterMsgData ();
        data.setOpenid (openid);
        // 场景枚举值（1 资料；2 评论；3 论坛；4 社交日志）
        data.setScene (2);
        // 接口版本号，2.0版本为固定值2
        data.setVersion (2);
        // 评论的类容
        data.setContent (content);
        ReturnMsgData returnMsgData = filterMsgTool.filterMsgTools (data);
        if (returnMsgData.getErrcode () == 0) {
            //评判成功
            /*
             Label:命中标签枚举值
                100 正常 ;
             建议:
                risky 风险、
                pass 通过、
                review 审查三种值
             */
            if (returnMsgData.getResult ().getLabel ().equals ("100")
                    && returnMsgData.getResult ().getSuggest ().equals ("pass")) {
                rtn = 1;
            } else {
                rtn = -3;
            }
        }
        return rtn;
    }

    /**
     * 在小程序端进行评论。添加评论
     *
     * @param coursecomment
     * @return Integer
     * -2 用户未登录，或者登录超时
     * 0 评论失败
     * -1 评论内容验证超时
     * -3 评论内容有敏感内容
     */
    @Override
    public Integer insetCourseComment(Coursecomment coursecomment, String token) {
        CurrentUser user = tools.getCurrentUserFromRedis (token);
        if (user == null || user.getUser () == null) {
            return -2;
        }
        //验证内容是否合法
        int checkflag = checkcontent (user.getUser ().getOpenid (), coursecomment.getCommentcontent ());
        if (checkflag == 1) {
            // 默认为 0
            coursecomment.setCommentscore (0);
            // 当前用户id
            coursecomment.setCommentuser (user.getUser ().getUserid ());
            //评论人姓名（使用昵称）
            coursecomment.setCommentusertruename (user.getUser ().getNickname ());
            //评论时间 当前时间
            coursecomment.setCommenttime (new Date ());
            //评论状态	commentstate	Integer		默认：1
            coursecomment.setCommentstate (1);
            // 评论是否展示(由用户设置)
            //coursecomment.setCommentisshow(0);
            // 是否加精	commentdigest	Integer		默认：0
            coursecomment.setCommentdigest (0);
            // 是否置顶	commenttop	Integer		默认0
            if(coursecomment.getCommenttop()==null){
                coursecomment.setCommenttop (0);
            }
            //  父评论id	commentpid	Integer		评论默认：-1
////            if(coursecomment.getCommentpid() != null && coursecomment.getCommentpid()!=-1){
////            }
//            coursecomment.setCommentpid(-1);
            //评论类型	commenttype	Integer		提问：2 默认提问 1--评论 2--提问
            //if (coursecomment.getCommenttype() == null) {
            //    coursecomment.setCommenttype(2);
            //}
            //是否回复	commentre	Integer		默认：0
            //如果是教师回复，则需要修改原来的提问-教师已回复，并将本条回复置为置顶。
            if(coursecomment.getCommentre()!=null && coursecomment.getCommentre()==1){
                //教师回复记录不需要再回复
                Coursecomment comment = new Coursecomment();
                comment.setCommentre(1);
                comment.setCommentid(coursecomment.getCommentpid());
                updateCommentById(comment);
            }
            coursecomment.setCommentre (0);
            coursecomment.setUserimgurl (user.getUser ().getShowpic ());
            checkflag = mapper.insert (coursecomment); // 插入评论成功
        }
        return checkflag;
    }

    /**
     * <p>
     * 对已经插入评论 进行评价
     * 1、 Courseid commentcontent			课程id  评论内容 ，不能为空
     * 2 、commenttype	Integer		评论：1 默认    1--评论 2--提问
     *
     * @param coursecomment
     * @return Integer
     * 成功返回1 失败返回0
     */
    @Override
    @Deprecated
    public Integer insetCourseComments(Coursecomment coursecomment, String token) {
        CurrentUser user = tools.getCurrentUserFromRedis (token);
        if (user == null && coursecomment == null && user.getUser () == null) {
            return 0;
        }
        // 	Courseid commentcontent			 评论内容 ，不能为空
        if (coursecomment.getCommentcontent () == null && coursecomment.getCourseid () == null) {
            return 0;
        }
        // 条件构造
        FilterMsgData data = new FilterMsgData ();
        data.setOpenid (user.getUser ().getOpenid ());
        // 场景枚举值（1 资料；2 评论；3 论坛；4 社交日志）
        data.setScene (2);
        // 接口版本号，2.0版本为固定值2
        data.setVersion (2);
        // 评论的类容
        data.setContent (coursecomment.getCommentcontent ());
        ReturnMsgData returnMsgData = filterMsgTool.filterMsgTools (data);
        // 评论的内容过滤 成功
        if (returnMsgData.getErrcode () == 0) {
            // Label 命中标签枚举值，100 正常 ; 建议，有risky 风险、pass 通过、review 审查三种值
            if (returnMsgData.getResult ().getLabel ().equals ("100") && returnMsgData.getResult ().getSuggest ().equals ("pass")) {
                // 默认为 0
                coursecomment.setCommentscore (0);
                // 当前用户id
                coursecomment.setCommentuser (user.getUser ().getUserid ());
                //评论人姓名（使用昵称）
                //当前用户的昵称（真实姓名）
                coursecomment.setCommentusertruename (user.getUser ().getNickname ());
                //评论时间 当前时间
                coursecomment.setCommenttime (new Date ());
                //评论状态	commentstate	Integer		默认：1
                coursecomment.setCommentstate (1);
                // 评论是否展示	commentisshow	Integer		默认：1展示
                coursecomment.setCommentisshow (1);
                // 是否加精	commentdigest	Integer		默认：0
                coursecomment.setCommentdigest (0);
                // 是否置顶	commenttop	Integer		默认0
                coursecomment.setCommenttop (0);
                //评论类型	commenttype	Integer		提问：1 默认提问 1--评论 2--提问
                coursecomment.setCommenttype (1);
                //是否回复	commentre	Integer		默认：0
                coursecomment.setCommentre (0);
                coursecomment.setUserimgurl (user.getUser ().getShowpic ());
                return mapper.insert (coursecomment);

            } else {
                // 评论内容 存在风险
                return -2;
            }
            // 评论过滤失败
        } else if (returnMsgData.getErrcode () == -1) {
            // -1	系统繁忙，此时请开发者稍候再试
            return -1;
        }
        return 0;
    }


    /**
     * wx & 支招模块
     * <p>
     * 根据评论d 查询评论或提问的评论
     *
     * @param CommentID
     * @return List<Coursecomment>
     **/
    @Override
    public List<Coursecomment> selectCommentListById(Integer CommentID) {
        return mapper.selectList (new QueryWrapper<Coursecomment> ().eq ("commentpid", CommentID));
    }

    /**
     * 查询 评论
     *
     * @return List<Coursecomment>
     **/
    @Override
    public List<Coursecomment> selectCommentList(Integer CourseId) {
        QueryWrapper<Coursecomment> wrapper = new QueryWrapper<> ();
        // 评论是否展示 判断
        wrapper.eq ("commentisshow", 1);
        // 判断是否是 评论  1
        wrapper.eq ("commenttype", 1);
        // 父评论id，课程评论=-1
        wrapper.eq ("commentpid", -1);
        // 1）置顶的评论放在最上面；
        wrapper.orderByDesc ("commenttop");
        // 2）置顶之下放置“加精”的评论
        wrapper.orderByDesc ("commentdigest");
        // 3）普通评论以时间倒序排列
        wrapper.orderByDesc ("commenttime");
        // 4）每个课程的评论只显示最多10条评论，如
        wrapper.last ("limit 10");
        return mapper.selectList (wrapper);
    }

    /**
     * 分页查询课程的评论
     *
     * @param courseId 课程id
     * @param pagenum  第几页
     * @param pagesize 每页多少行
     * @return
     */
    @Override
    public Page<CoursecommentDto> selectCommentByPage(Integer courseId, Long pagenum, Long pagesize) {
        Page<CoursecommentDto> page = new Page<> (pagenum, pagesize);
//        QueryWrapper<Coursecomment> wrapper = new QueryWrapper<>();
//        wrapper.eq("courseid",courseId);
//        wrapper.eq("commentstate",1);
//        wrapper.eq("commentisshow",1);
//        wrapper.eq("commentpid",-1);
//        wrapper.orderByDesc("commenttop","commentdigest","commenttime");
//        return mapper.selectPage(page,wrapper);
        return mapper.selectCommnetPageByCourseId (courseId, page);
    }

    /**
     * 根据评论id查询评论详细信息，包含评论的课程名称
     *
     * @param commentid 评论id
     * @return
     */
    @Override
    public CoursecommentDto selectCommentById(Integer commentid) {
        return mapper.selectCommentById (commentid);
    }

    /**
     * 分页查询评论回复列表
     * 排序规则：置顶--加精--时间倒序
     *
     * @param commentid 评论id
     * @param pagenum   第几页
     * @param pagesize  每页多少行
     * @return
     */
    @Override
    public Page<Coursecomment> selectReCommentByPage(Integer commentid, Long pagenum, Long pagesize) {
        Page<Coursecomment> page = new Page<> (pagenum, pagesize);
        QueryWrapper<Coursecomment> wrapper = new QueryWrapper<> ();
        wrapper.eq ("commentstate", 1);
        wrapper.eq ("commentisshow", 1);
        wrapper.eq ("commentpid", commentid);
        wrapper.orderByDesc ("commenttop", "commentdigest", "commenttime");
        return mapper.selectPage (page, wrapper);
    }


    /**
     * 我的提问
     * <p>
     * 根据用户的id 查询 我的提问列表
     *
     * @param token
     * @return List<Coursecomment>
     **/
    @Override
    public List<CoursecommentDto> selectMyQuestionsCommentList(String token) {
        CurrentUser user = tools.getCurrentUserFromRedis (token);
        if (user != null && user.getUser () != null) {
            return mapper.selectMyQuestionsCommentList (user.getUser ().getUserid ());
        }
        return null;
    }

    /**
     * 我的评论
     * <p>
     * 根据用户的id 查询 我的提问列表
     *
     * @param token
     * @return List<Coursecomment>
     **/
    @Override
    public List<CoursecommentDto> selectMyCommentList(String token) {
        CurrentUser user = tools.getCurrentUserFromRedis (token);
        if (user != null && user.getUser () != null) {
            return mapper.selectMyCommentList (user.getUser ().getUserid ());
        }
        return null;
    }

    /**
     * 统计评论条数
     * 根据课程id
     *
     * @param CourseId
     * @return Int
     */
    @Override
    public Integer countComment(Integer CourseId) {
        return mapper.countComment (CourseId);
    }

    /**
     * 统计提问条数
     * 根据课程id
     *
     * @param CourseId
     * @return Int
     */
    @Override
    public Integer countQuestions(Integer CourseId) {
        // 条件 课程ID 评论类型 2->提问  commentpid -1 ->父评论id
        return mapper.selectCount (new QueryWrapper<Coursecomment> ().eq ("courseid", CourseId).eq ("commenttype", 2).eq ("commentpid", -1));
    }

    /**
     * 根据用户id查询用户的提问或者评论
     *
     * @param userid      用户id
     * @param commenttype 1评论；2提问
     * @return 返回null表示用户没有登录
     */
    @Override
    public Page<CoursecommentDto> selectCommentPageByUserId(Integer userid,
                                                            Integer commenttype,
                                                            Long pagenum,
                                                            Long pagesize) {

        Page<CoursecommentDto> page = new Page<> (pagenum, pagesize);
        return mapper.selectCommentPageByUserId (userid, commenttype, page);
    }

    /**
     * 根据教师id查询教师所有的课程的提问和评论
     *
     * @param teacherid   教师id
     * @param commenttype 1评论；2提问
     * @param pagenum
     * @param pagesize
     * @return
     */
    @Override
    public Page<CoursecommentDto> selectCommentPageByTeacherId(Integer teacherid, Integer commenttype, Long pagenum, Long pagesize) {
        Page<CoursecommentDto> page = new Page<> (pagenum, pagesize);
        return mapper.selectCommentPageByTeacherId (teacherid, commenttype, page);
    }

    /**
     * 根据教师id查询该教师还有多少未回复的提问
     *
     * @param teacherid 教师id
     * @return
     */
    @Override
    public int selectNotReCommentByTeacherId(Integer teacherid) {
        return mapper.selectNotReCommentByTeacherId (teacherid);
    }

    /**
     * 据课程评论的id
     * 进行修改 评论的置顶，加精
     *
     * @param coursecomment
     * @return int
     */
    @Override
    public Integer updateCommentById(Coursecomment coursecomment) {
        //据课程评论的id 进行修改 评论的置顶，加精
        return mapper.updateById (coursecomment);
    }
}
